#ifndef SAMPLE_H
#define SAMPLE_H
#include <algorithm>
#include <ctime>
#include <iostream>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <typeinfo>
#include <unordered_map>
#include <utility>
#include <vector>
namespace nil01 {

void main_func();
void test_std_conditional();

}  // namespace nil01

namespace nil02 {

void test_vector(long& value);

class sample {
 public:
  sample();
};

template <typename T, typename Func>
class ResourceGuard {
 public:
  ResourceGuard(T* _obj, Func _func) : obj(_obj), func(_func) {}

  ~ResourceGuard() { func(obj); }

 private:
  T* obj;
  Func func;
};

template <typename T>
class Ref {
 public:
  Ref() = delete;
  Ref(T& _data) : data(_data) {}

  T& operator()() const noexcept { return *data; }

 private:
  T* data;
};

}  // namespace nil02

#include <memory>
namespace nil03 {
void main_func();
void unique_ptr_func();
void shared_ptr_func();

void Check(std::weak_ptr<int>& wp);

void check_shared_ptr();

}  // namespace nil03

#include <pthread.h>
#include <unistd.h>

#include <atomic>
#include <thread>
namespace nil04 {

void main_func();

void old_thread_func();
void* old_func(void*);

void cpp11_thread_func();
void cpp11_atomic_func();
}  // namespace nil04

// containers
#include <array>
#include <deque>
#include <forward_list>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>
namespace nil05 {
void main_func();
void cpp11_array();
void cpp11_vector();
void cpp11_list();
void cpp11_forward_list();
void cpp11_deque();
void cpp11_stack();
void cpp11_queue();
void cpp11_array_sort();
void cpp11_unorderdmap();

}  // namespace nil05

namespace nil06 {}
#endif  // SAMPLE_H
